              package com.java.diagnostics.visualizer.parser.vgc.constants;
              
              import com.java.diagnostics.visualizer.data.axes.XAxis;
              import com.java.diagnostics.visualizer.data.axes.XDataAxis;
              import com.java.diagnostics.visualizer.data.axes.YAxis;
              import com.java.diagnostics.visualizer.data.axes.YDataAxis;
              import com.java.diagnostics.visualizer.exceptions.GCAndMemoryVisualizerException;
              import com.java.diagnostics.visualizer.factory.DataFactory;
              import com.java.diagnostics.visualizer.gc.defaultextensions.util.Messages;
              import com.java.diagnostics.visualizer.impl.axes.AxisUnits;
              import com.java.diagnostics.visualizer.impl.factory.LogFactory;
              import com.java.diagnostics.visualizer.parser.vgc.converters.ActionUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.BytesToGigabytesUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.BytesToKilobytesUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.BytesToMegabytesUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.DateUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.DaysUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.GCNumberConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.GCReasonUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.GCScopeUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.HoursUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.HundredsUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.MicroSecondsUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.MillisecondsToSecondsUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.MinutesUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.SecondsUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.WRTEventUnitConverter;
              import com.java.diagnostics.visualizer.parser.vgc.converters.WRTQuantumTypeConverter;
              import com.java.diagnostics.visualizer.properties.OutputProperties;
              import com.java.diagnostics.visualizer.sources.Source;
              import java.util.logging.Logger;
              
              public class VGCAxes
              {
                private static final Logger TRACE = LogFactory.getTrace(VGCAxes.class);
              
                public static final String PERCENT_SIGN = AxisUnits.PERCENT_SIGN;
                public static final String PERCENT_ID = "VGCAxes.percent";
                public static final String PERCENT = Messages.getString("VGCAxes.percent");
              
                public static final String TIMES_SIGN = AxisUnits.TIMES_SIGN;
                public static final String RATE_ID = "VGCAxes.rate";
                public static final String RATE = Messages.getString("VGCAxes.rate");
                public static final String HITS_ID = "VGCAxes.hits";
                public static final String HITS = Messages.getString("VGCAxes.hits");
              
                public static final String HASH_SIGN = AxisUnits.HASH_SIGN;
                public static final String NUMBER_ID = "VGCAxes.number";
                public static final String NUMBER = Messages.getString("VGCAxes.number");
              
                public static final String HUNDREDS = AxisUnits.HUNDREDS;
              
                public static final String KB = AxisUnits.KB;
                public static final String MB = AxisUnits.MB;
                public static final String GB = AxisUnits.GB;
                public static final String BYTES = AxisUnits.BYTES;
                public static final String DATA_ID = "VGCAxes.data";
                public static final String DATA = Messages.getString("VGCAxes.data");
                public static final String HEAP_ID = "VGCAxes.heap";
                public static final String HEAP = Messages.getString("VGCAxes.heap");
                public static final String TIME_ID = "VGCAxes.time";
                public static final String TIME = Messages.getString("VGCAxes.time");
                public static final String NORMALISED_TIME_ID = "VGCAxes.time.from.start";
                public static final String NORMALISED_TIME = Messages.getString("VGCAxes.time.from.start");
              
                public static final String SECONDS = AxisUnits.SECONDS;
                public static final String MICROSECONDS = AxisUnits.MICROSECONDS;
              
                public static final String NUMBER_OF_FLIPS = AxisUnits.NUMBER_OF_FLIPS;
                public static final String AGE_ID = "VGCAxes.age";
                public static final String AGE = Messages.getString("VGCAxes.age");
              
                public static final String OBJECTS = AxisUnits.OBJECTS;
              
                public static final String NUMBER_FLIPPED = AxisUnits.NUMBER_FLIPPED;
              
                public static final String COLLECTION = Messages.getString("VGCAxes.collection");
              
                public static final String TIMESTAMP = Messages.getString("VGCAxes.timestamp");
                public static final String GC_NUMBER_ID = "VGCAxes.gc.number";
                public static final String GC_NUMBER = AxisUnits.GC_COUNT;
              
                public static final String DAYS = AxisUnits.DAYS;
              
                public static final String TOTAL_HEAP = Messages.getString("StrictJ950VGCParser.total.heap");
              
                public static final String TENURED_HEAP = Messages.getString("StrictJ950VGCParser.tenured.heap");
              
                public static final String NURSERY_HEAP = Messages.getString("StrictJ950VGCParser.nursery.heap");
              
                public static final String PERMANENT_HEAP = Messages.getString("VGCLabels.permanent.heap");
              
                public static final String DATE = AxisUnits.DATE;
                public static final String ACTION_ID = "VGCAxes.action";
                public static final String ACTION = Messages.getString("VGCAxes.action");
              
                public static final String MILLISECONDS = AxisUnits.MILLISECONDS;
                public static final String HOURS = AxisUnits.HOURS;
                public static final String MINUTES = AxisUnits.MINUTES;
                public static final String ACTIONCODE = AxisUnits.ACTION_CODE;
                public static final String REASONCODE = AxisUnits.REASON_CODE;
                public static final String EVENTCODE = AxisUnits.EVENT_CODE;
                public static final String EVENTUNITS = AxisUnits.EVENT_TYPE;
                public static final String SCOPECODE = AxisUnits.TYPE_CODE;
                public static final String QUANTUMTYPECODE = AxisUnits.QUANTUM_TYPE_CODE;
                public static final String AFSUCCESS_ID = "VGCAxes.af.success";
                public static final String AFSUCCESS = Messages.getString("VGCAxes.af.success");
                public static final String GCPERCOLATED_ID = "VGCAxes.gc.percolated";
                public static final String GCPERCOLATED = Messages.getString("VGCAxes.gc.percolated");
                public static final String SCOPE_ID = "VGCAxes.gc.scope";
                public static final String SCOPE = Messages.getString("VGCAxes.gc.scope");
                public static final String REASON_ID = "VGCAxes.gc.type";
                public static final String REASON = Messages.getString("VGCAxes.gc.type");
                public static final String EVENT_ID = "VGCAxes.event.type";
                public static final String EVENT = Messages.getString("VGCAxes.event.type");
                public static final String QUANTUM_TYPE_ID = "WRTLabels.quantum.type";
                public static final String QUANTUM_TYPE = Messages.getString("WRTLabels.quantum.type");
              
                private static final DataFactory FACTORY = DataFactory.getFactory("TRACE");
              
                private static final DataFactory factory = DataFactory.getFactory("VGC");
              
                private static YAxis getObjectsMovedAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("OBJECTS_MOVED_AXIS")) == null)
                  {
                    axis = factory.createYAxis("VGCAxes.moved", 
                      Messages.getString("VGCAxes.moved"), BYTES);
                    outputProperties.setYAxis("OBJECTS_MOVED_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getObjectsCopiedAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("OBJECTS_COPIED_AXIS")) == null)
                  {
                    axis = factory.createYAxis("VGCAxes.copied", 
                      Messages.getString("VGCAxes.copied"), BYTES);
                    outputProperties.setYAxis("OBJECTS_copied_AXIS", axis);
                  }
                  return axis;
                }
              
                protected static XAxis getXAxis(OutputProperties outputProperties)
                {
                  XAxis axis;
                  if ((axis = outputProperties.getXAxis()) == null) {
                    axis = factory.createXAxis("VGCAxes.time.from.start", NORMALISED_TIME, 
                      MILLISECONDS);
                    outputProperties.setXAxis(axis);
                  }
                  return axis;
                }
              
                private static YAxis getTimeAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("TIME_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.time", TIME, MILLISECONDS);
                    outputProperties.setYAxis("TIME_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getDiscreteTimeAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("DISCRETE_TIME_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.time", TIME, 
                      MILLISECONDS, 2);
                    outputProperties.setYAxis("DISCRETE_TIME_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getActionAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("ACTION_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.action", ACTION, ACTIONCODE, 
                      2);
                    outputProperties.setYAxis("ACTION_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getHeapAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("HEAP_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.heap", HEAP, BYTES);
                    outputProperties.setYAxis("HEAP_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getBytesAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("BYTES_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.data", DATA, BYTES);
                    outputProperties.setYAxis("BYTES_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getNumberAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("NUMBER_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.number", NUMBER, HASH_SIGN);
                    outputProperties.setYAxis("NUMBER_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getRateAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("RATE_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.rate", RATE, TIMES_SIGN);
                    outputProperties.setYAxis("RATE_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getPercentAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("PERCENT_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.percent", PERCENT, PERCENT_SIGN);
                    outputProperties.setYAxis("PERCENT_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getAgeAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("AGE_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.age", AGE, NUMBER_OF_FLIPS);
                    outputProperties.setYAxis("AGE_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getReasonAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("TYPE_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.gc.type", REASON, REASONCODE, 
                      2);
                    outputProperties.setYAxis("TYPE_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getEventAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("EVENT_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.event.type", EVENT, EVENTCODE, 
                      2);
                    outputProperties.setYAxis("EVENT_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getQuantumTypeAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("QUANTUM_TYPE_AXIS")) == null) {
                    axis = factory.createYAxis("WRTLabels.quantum.type", QUANTUM_TYPE, QUANTUMTYPECODE, 
                      2);
                    outputProperties.setYAxis("QUANTUM_TYPE_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getScopeAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("SCOPE_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.gc.scope", SCOPE, SCOPECODE, 
                      2);
                    outputProperties.setYAxis("SCOPE_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getAFSuccessAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("AFSUCCESS_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.af.success", AFSUCCESS, NUMBER);
                    outputProperties.setYAxis("AFSUCCESS_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getGCPercolatedAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("GC_PERCOLATED_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.gc.percolated", GCPERCOLATED, NUMBER, 
                      2);
                    outputProperties.setYAxis("GC_PERCOLATED_AXIS", axis);
                  }
                  return axis;
                }
              
                private static YAxis getRestartAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("RESTART_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.restart", 
                      Messages.getString("VGCAxes.restart"), 
                      Messages.getString("VGCAxes.restart.units"), 1);
                    outputProperties.setYAxis("RESTART_AXIS", axis);
                  }
                  return axis;
                }
              
                public static XDataAxis prepareXAxis(Source source, GCNumberConverter gcNumberConverter, OutputProperties properties)
                {
                  XDataAxis xAxis = getXAxis(properties).createDataAxis(source, 
                    properties);
                  try {
                    if (gcNumberConverter != null) {
                      xAxis.addUnitConverter(gcNumberConverter);
                    }
                    xAxis.addUnitConverter(new HoursUnitConverter());
                    xAxis.addUnitConverter(new MinutesUnitConverter());
                    xAxis.addUnitConverter(new SecondsUnitConverter());
                    xAxis.addUnitConverter(new DateUnitConverter());
                    xAxis.addUnitConverter(new DaysUnitConverter());
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
              
                  return xAxis;
                }
              
                public static XDataAxis prepareXAxis(Source source, GCNumberConverter gcNumberConverter, OutputProperties properties, boolean supportNormalisation)
                {
                  XDataAxis xAxis = getXAxis(properties).createDataAxis(source, 
                    supportNormalisation, properties);
                  try {
                    if (gcNumberConverter != null) {
                      xAxis.addUnitConverter(gcNumberConverter);
                    }
                    xAxis.addUnitConverter(new HoursUnitConverter());
                    xAxis.addUnitConverter(new MinutesUnitConverter());
                    xAxis.addUnitConverter(new SecondsUnitConverter());
                    xAxis.addUnitConverter(new DateUnitConverter());
                    xAxis.addUnitConverter(new DaysUnitConverter());
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
              
                  return xAxis;
                }
              
                public static YDataAxis prepareHeapAxis(OutputProperties properties) {
                  YDataAxis heapAxis = getHeapAxis(properties).createDataAxis(false, 
                    properties);
                  try
                  {
                    heapAxis.addUnitConverter(new BytesToKilobytesUnitConverter());
                    heapAxis.addUnitConverter(new BytesToMegabytesUnitConverter());
                    heapAxis.addUnitConverter(new BytesToGigabytesUnitConverter());
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
                  return heapAxis;
                }
              
                public static YDataAxis prepareBytesAxis(OutputProperties properties)
                {
                  YDataAxis bytesAxis = getBytesAxis(properties).createDataAxis(false, 
                    properties);
                  try
                  {
                    bytesAxis.addUnitConverter(new BytesToKilobytesUnitConverter());
                    bytesAxis.addUnitConverter(new BytesToMegabytesUnitConverter());
                    bytesAxis.addUnitConverter(new BytesToGigabytesUnitConverter());
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
                  return bytesAxis;
                }
              
                public static YDataAxis prepareObjectsMovedAxis(OutputProperties properties) {
                  YDataAxis axis = getObjectsMovedAxis(properties).createDataAxis(false, 
                    properties);
                  try
                  {
                    axis.addUnitConverter(new BytesToKilobytesUnitConverter());
                    axis.addUnitConverter(new BytesToMegabytesUnitConverter());
                    axis.addUnitConverter(new BytesToGigabytesUnitConverter());
                  } catch (GCAndMemoryVisualizerException e) {
                    e.printStackTrace();
                  }
                  return axis;
                }
              
                public static YDataAxis prepareObjectsCopiedAxis(OutputProperties properties) {
                  YDataAxis axis = getObjectsCopiedAxis(properties).createDataAxis(false, 
                    properties);
                  try {
                    axis.addUnitConverter(new BytesToKilobytesUnitConverter());
                    axis.addUnitConverter(new BytesToMegabytesUnitConverter());
                    axis.addUnitConverter(new BytesToGigabytesUnitConverter());
                  } catch (GCAndMemoryVisualizerException e) {
                    e.printStackTrace();
                  }
                  return axis;
                }
              
                public static YDataAxis prepareGCScopeAxis(OutputProperties properties)
                {
                  YDataAxis axis = getScopeAxis(properties).createDataAxis(false, 
                    properties);
                  try
                  {
                    GCScopeUnitConverter scopeUnitConverter = new GCScopeUnitConverter();
                    axis.addUnitConverter(scopeUnitConverter);
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
                  return axis;
                }
              
                public static YDataAxis prepareAFSuccessAxis(OutputProperties properties)
                {
                  YDataAxis axis = getAFSuccessAxis(properties).createDataAxis(false, 
                    properties);
              
                  return axis;
                }
              
                public static YDataAxis prepareGCPercolatedAxis(OutputProperties properties)
                {
                  YDataAxis axis = getGCPercolatedAxis(properties).createDataAxis(false, 
                    properties);
              
                  return axis;
                }
              
                public static YDataAxis prepareGCReasonsAxis(OutputProperties properties)
                {
                  YDataAxis axis = getReasonAxis(properties).createDataAxis(false, 
                    properties);
                  try
                  {
                    GCReasonUnitConverter reasonUnitConverter = new GCReasonUnitConverter();
                    axis.addUnitConverter(reasonUnitConverter);
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
                  return axis;
                }
              
                public static YDataAxis prepareEventAxis(OutputProperties properties)
                {
                  YDataAxis axis = getEventAxis(properties).createDataAxis(false, 
                    properties);
                  try {
                    WRTEventUnitConverter converter = new WRTEventUnitConverter();
                    axis.addUnitConverter(converter);
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
                  return axis;
                }
              
                public static YDataAxis prepareQuantumTypeAxis(OutputProperties properties)
                {
                  YDataAxis axis = getQuantumTypeAxis(properties).createDataAxis(false, 
                    properties);
                  try {
                    WRTQuantumTypeConverter converter = new WRTQuantumTypeConverter();
                    axis.addUnitConverter(converter);
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
                  return axis;
                }
              
                public static YDataAxis prepareDiscreteTimeAxis(OutputProperties properties)
                {
                  YDataAxis discreteTimeAxis = getDiscreteTimeAxis(properties)
                    .createDataAxis(false, properties);
                  try {
                    discreteTimeAxis
                      .addUnitConverter(new MillisecondsToSecondsUnitConverter());
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
                  return discreteTimeAxis;
                }
              
                private static YAxis getDiscreteNumberAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("DISCRETE_NUMBER_AXIS")) == null) {
                    axis = factory.createYAxis("VGCAxes.number", NUMBER, HASH_SIGN, 
                      2);
                    outputProperties.setYAxis("DISCRETE_NUMBER_AXIS", axis);
                  }
                  return axis;
                }
              
                public static YDataAxis prepareDiscreteNumberAxis(OutputProperties properties)
                {
                  YDataAxis axis = getDiscreteNumberAxis(properties)
                    .createDataAxis(false, properties);
                  try {
                    HundredsUnitConverter hundredsConverter = new HundredsUnitConverter();
                    axis.addUnitConverter(hundredsConverter);
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
                  return axis;
                }
              
                public static YDataAxis prepareTimeAxis(OutputProperties properties) {
                  YDataAxis axis = getTimeAxis(properties).createDataAxis(false, 
                    properties);
                  try
                  {
                    MillisecondsToSecondsUnitConverter secondsUnitConverter = new MillisecondsToSecondsUnitConverter();
                    axis.addUnitConverter(new MicroSecondsUnitConverter());
                    axis.addUnitConverter(secondsUnitConverter);
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
                  return axis;
                }
              
                public static YDataAxis prepareActionAxis(OutputProperties properties) {
                  YDataAxis axis = getActionAxis(properties).createDataAxis(false, 
                    properties);
                  try
                  {
                    ActionUnitConverter unitConverter = new ActionUnitConverter();
                    axis.addUnitConverter(unitConverter);
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
                  return axis;
                }
              
                public static YDataAxis prepareNumberAxis(OutputProperties properties) {
                  YDataAxis axis = getNumberAxis(properties).createDataAxis(false, 
                    properties);
                  try
                  {
                    HundredsUnitConverter hundredsConverter = new HundredsUnitConverter();
                    axis.addUnitConverter(hundredsConverter);
                  } catch (GCAndMemoryVisualizerException e) {
                    TRACE.warning(e.toString());
                  }
                  return axis;
                }
              
                public static YDataAxis preparePercentAxis(OutputProperties properties) {
                  return getPercentAxis(properties).createDataAxis(properties);
                }
              
                public static YDataAxis prepareRateAxis(OutputProperties properties) {
                  return getRateAxis(properties).createDataAxis(properties);
                }
              
                public static YDataAxis prepareAgeAxis(OutputProperties properties) {
                  return getAgeAxis(properties).createDataAxis(properties);
                }
              
                public static YDataAxis prepareRestartAxis(OutputProperties properties) {
                  return getRestartAxis(properties).createDataAxis(properties);
                }
              
                private static YAxis getYAxis(OutputProperties outputProperties)
                {
                  YAxis axis;
                  if ((axis = outputProperties.getYAxis("Y_AXIS")) == null) {
                    axis = FACTORY.createYAxis("VGCAxes.hits", HITS, HASH_SIGN, 2);
                    outputProperties.setYAxis("Y_AXIS", axis);
                  }
                  return axis;
                }
              
                public static YDataAxis prepareYAxis(OutputProperties properties) {
                  return getYAxis(properties).createDataAxis(properties);
                }
              }

